package exam;

import java.util.HashMap;
import java.util.Map;

public class test6 {

    public static void main(String[] args) {

    }

    public int[][] matrixBlockSum(int[][] mat, int k) {
        int m=mat.length;
        int n=mat[0].length;

        int [][]arr=new int[m+1][n+1];

        for(int i=1;i<m+1;i++){
            for(int j=1;j<n+1;j++){
                arr[i][j]=arr[i-1][j]+arr[i][j-1]-arr[i-1][j-1]+mat[i-1][j-1];
            }
        }


        int [][]ret=new int[m][n];

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                int x1=i-k,y1=j-k,x2=i+k,y2=j+k;
                if(x1<0)x1=0;
                if(y1<0)y1=0;
                if(x2>m-1)x2=m-1;
                if(y2>n-1)y2=n-1;
                ret[i][j]=arr[x2+1][y2+1]-arr[x2+1][y1]-arr[x1][y2+1]+arr[x1][y1];
            }
        }
        return ret;
    }


    public int findMaxLength1(int[] nums) {
        int sum=0;
        int ret=0;
        Map<Integer,Integer>map=new HashMap<>();
        map.put(0,-1);
        for(int i=0;i<nums.length;i++){
            sum+=nums[i]==0?-1:1;
            if(map.containsKey(sum)){
                ret=Math.max(ret,i-map.get(sum));
            }else{
                map.put(sum,i);
            }
        }
        return ret;
    }

    public int findMaxLength(int[] nums) {
        int sum=0;
        int len=0;
        Map<Integer,Integer>map=new HashMap<>();
        map.put(0,-1);
        for(int i=0;i<nums.length;i++){
            if(nums[i]==0){
                sum+=-1;
            }else{
                sum+=nums[i];
            }
            int l=map.getOrDefault(sum,i);
            if(i==l){
                map.put(sum,i);
            }

            if(i-l>len){
                len=i-l;
            }
        }
        return len;
    }

    public int subarraysDivByK(int[] nums, int k) {
        Map<Integer,Integer>map=new HashMap<>();
        int sum=0,ret=0;
        map.put(0,1);
        for(int x:nums){
            sum+=x;
            int l=(sum%k+k)%k;
            ret+=map.getOrDefault(l,0);
            map.put(l,map.getOrDefault(l,0)+1);
        }
        return ret;
    }


    public int subarraySum(int[] nums, int k) {
        Map<Integer,Integer>map=new HashMap<>();
        map.put(0,1);

        int sum=0,ret=0;

        for(int x:nums){
            sum+=x;
            ret+=map.getOrDefault(sum-k,0);
            map.put(sum,map.getOrDefault(sum,0)+1);
        }
        return ret;
    }



    public int[] productExceptSelf(int[] nums) {
        int len=nums.length;
        int []f=new int [len];
        int[]g=new int[len];
        f[0]=1;
        g[len-1]=1;

        for(int i=1;i<len;i++){
            f[i]=f[i-1]*nums[i-1];
        }

        for(int i=len-2;i>=0;i--){
            g[i]=g[i+1]*nums[i+1];
        }

        for(int i=0;i<len;i++){
            nums[i]=f[i]*g[i];
        }
        return nums;

    }

    public int pivotIndex(int[] nums) {
        int len=nums.length;
        int []f=new int[len];
        int []g=new int[len];

        f[0]=0;
        g[len-1]=0;

        for(int i=1;i<len;i++){
            f[i]=f[i-1]+nums[i-1];
        }

        for(int i=len-2;i>=0;i--){
            g[i]=g[i+1]+nums[i+1];
        }

        for(int i=0;i<len;i++){
            if(f[i]==g[i]){
                return i;
            }
        }
        return -1;
    }
}
